package sanrenxing.Paper.dao.impl;

import com.mysql.cj.jdbc.util.TimeUtil;
import sanrenxing.Paper.dao.PaperDao;
import sanrenxing.Paper.domain.*;
import sanrenxing.reexams.domain.PaperId;
import sanrenxing.utils.JdbcUtils;

import java.sql.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;


/**
 * 功能：试卷信息表的数据实现类
 * 编写者：张港峰
 * 日期：20200928
 * 版本：1.0
 */
public class PaperDaoImpl implements PaperDao {
    /**
     *
     * @param classId
     * @return
     */
    public List<Student> QueryAllStudent(int classId){
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义一个返回的学生集合对象
        List<Student> students=new ArrayList<>();
        try {
            //实例化数据库连接对象
            conn=JdbcUtils.getConnection();
            //编写SQL命令语句
            String sql="SELECT * FROM student WHERE classId=?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给SQL命令中的占位符赋值
            pstmt.setInt(1,classId);
            //返回结果集
            rs=pstmt.executeQuery();
            while(rs.next()){
                //定义学生对象
                Student student=new Student(
                        rs.getString("stuId"),
                        rs.getString("stuName"),
                        rs.getString("stuSex"),
                        rs.getInt("classId"),
                        rs.getString("selfId"),
                        rs.getString("stuPwd"),
                        rs.getString("stuPhone"),
                        rs.getString("stuItb")
                );
                //添加到学生集合中
                students.add(student);

            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            //释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回学生集合
        return students;
    }

    /**
     * 通过科目编号查询科目名称
     *
     * @param courseId 课程编号
     * @return
     */
    @Override
    public String findcourseName(int courseId) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        try {
            //实例化数据库连接对象
            conn=JdbcUtils.getConnection();
            //编写SQL命令语句
            String sql="select courseName from course where courseId=?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给SQL命令中的占位符赋值
            pstmt.setInt(1,courseId);
            //返回结果集
            rs=pstmt.executeQuery();
            if (rs.next()){
                //返回课程名称
                return rs.getString("courseName");
            }
        } catch (SQLException e) {
            //抛出异常
            new RuntimeException(e.getMessage(),e);
        }finally{
            //释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回空值
        return null;
    }

    /**
     * 添加一行数据
     * @param paper 试卷对象
     * @return
     */
    @Override
    public int add(Paper paper) {
        //定义一个影响的行数
        int rows=0;
        //声明数据库连接对象
        Connection conn=null;
        //声明数据库连接对象
        PreparedStatement pstmt=null;

        try {

            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写要执行的sql命令语句
            String sql="insert into paper(classId,courseId,examDate,beginTime,finishTime,subjectIds) values(?,?,?,?,?,?)";
            //实例化预编译对象
            pstmt=conn.prepareStatement(sql);
            //给sql命令中的占位符赋值
            pstmt.setInt(1,paper.getClassId());
            pstmt.setInt(2,paper.getCourseId());
            pstmt.setString(3,paper.getExamDate());
            pstmt.setString(4,paper.getBeginTime());
            pstmt.setString(5,paper.getFinishTime());
            pstmt.setString(6,paper.getSubjectIds());
            //使用预编译语句对象执行slq命令，并返回影响行数
            rows=pstmt.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            JdbcUtils.close(null,pstmt,conn);
        }

        return rows;
    }


    /**
     * 根据主键从试卷表中删除一行数据
     *
     * @param paperId 试卷编号
     * @return
     */
    @Override
    public int delete(int paperId) {
        //定义一个执行后影响行数的变量
        int rows=0;
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;


        try {
            //使用jdbcutils工具类实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //定义sql命令字符串
            String sql="delete from Paper where paperId=?";
            //使用数据库连接对象和sql字符串俩实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给sql命令中的占位符赋值
            pstmt.setInt(1,paperId);
            //使用预编译语句对象执行slq命令，并返回影响行数
            rows=pstmt.executeUpdate();
        } catch (SQLException e) {
            //运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回删除后影响的行数
        return rows;
    }

    /**
     * 将数据修改到数据库表中
     *
     * @param paper 试卷对象
     * @return影响的行数（1，修改成功，0，修改失败）
     */
    @Override
    public int update(Paper paper) {
        //定义一个执行后影响行数的变量
        int rows=0;
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;


        try {
            //使用jdbcutils工具类实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //定义sql命令字符串
            String sql="update  Paper set classId=?,courseId=?,subjectIds=?,examDate=?,beginTime=?,finishTime=? where paperId=?";
            //使用数据库连接对象和sql字符串俩实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给sql命令中的占位符赋值
            pstmt.setInt(1,paper.getClassId());
            pstmt.setInt(2,paper.getCourseId());
            pstmt.setString(3,paper.getSubjectIds());
            pstmt.setString(4,paper.getExamDate());
            pstmt.setString(5,paper.getBeginTime());
            pstmt.setString(6,paper.getFinishTime());
            pstmt.setInt(7,paper.getPaperId());

            //使用预编译语句对象执行slq命令，并返回影响行数
            rows=pstmt.executeUpdate();

        } catch (SQLException e) {
            //运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回影响的行数
        return rows;
    }

    /**
     * 查询一行数据
     *
     * @param paperId 试卷编号
     * @return
     */
    @Override
    public Paper findById(int paperId) {
        //定义员工对象
        Paper paper=null;
        //声明数据库连接对象
        Connection conn=null;
        //预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;

        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写要执行的sql命令语句
            String sql="select paperId,classId,courseId,subjectIds,examDate,beginTime,finishTime from Paper where paperId=?";
            //实例化预编语句
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setInt(1,paperId);

            //3 执行预编译语句对象 并返回结果集
            rs=pstmt.executeQuery();
            //4对结果集进行循环处理
            if(rs.next()){
                //实例化对象
                paper=new Paper();
                //把结果集中的一行数据赋值给试卷对象
                paper.setPaperId(rs.getInt("paperId"));
                paper.setClassId(rs.getInt("classId"));
                paper.setCourseId(rs.getInt("courseId"));
                paper.setSubjectIds(rs.getString("subjectIds"));
                paper.setExamDate(rs.getString("examDate"));
                paper.setBeginTime(rs.getString("beginTime"));
                paper.setFinishTime(rs.getString("finishTime"));

            }

        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回试卷对象
        return paper;
    }

    /**
     * 查询所有数据
     *
     * @return
     */
    @Override
    public List<Paper> findAll() {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的员工对象集合
        List<Paper> paperList=new ArrayList<Paper>();

        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写要执行的sql命令语句
            String sql="select * from Paper ";
            //实例化预编语句
            pstmt=conn.prepareStatement(sql);
            //执行sql命令语句
            rs=pstmt.executeQuery();
            //循环判断结果集
            while (rs.next()){
                //定义试卷对象
                Paper paper=new Paper();
                paper.setPaperId(rs.getInt("paperId"));
                paper.setClassId(rs.getInt("classId"));
                paper.setCourseId(rs.getInt("courseId"));
                paper.setSubjectIds(rs.getString("subjectId"));
                paper.setExamDate(rs.getString("examDate"));
                paper.setBeginTime(rs.getString("beginTime"));
                paper.setFinishTime(rs.getString("finishTime"));
                paperList.add(paper);
            }

        } catch (SQLException e) {
          //运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        return paperList;
    }

    /**
     * 多条件查询
     *
     * @param rows      每页行数
     * @param pages     页数
     * @param condition 条件
     * @return 试卷对象
     */
    @Override
    public List<PaperTo> findByPage(int rows, int pages, String condition) {
        //定义一个员工集合对象
        List<PaperTo> paperToList=new ArrayList<PaperTo>();
        //声明数据库连接对象
        Connection conn=null;
        //预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;

        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写要执行的sql命令
            String sql="SELECT p.paperId,cl.className,c.courseName,p.subjectIds,p.examDate,p.beginTime,p.finishTime FROM Paper p JOIN class cl ON p.classId=cl.classId JOIN course c ON p.courseId=c.courseId where 1=1"+condition+" limit ?,?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);

            //给分页语句赋值
            pstmt.setInt(1,(pages-1)*rows);
            pstmt.setInt(2,rows);

            //执行sql命令语句并返回结果集
            rs=pstmt.executeQuery();

            //对结果集进行循环处理
            while (rs.next()){
                //创建一个试卷对象
                PaperTo paperTo=new PaperTo();
                //把结果集中的一行数据赋值给试卷对象
                paperTo.setPaperId(rs.getInt("paperId"));
                paperTo.setClassName(rs.getString("className"));
                paperTo.setCourseName(rs.getString("courseName"));
                paperTo.setSubjectIds(rs.getString("subjectIds"));
                paperTo.setExamDate(rs.getString("examDate"));
                paperTo.setBeginTime(rs.getString("beginTime"));
                paperTo.setFinishTime(rs.getString("finishTime"));
                //把有数据的试卷对象添加到集合中间
                paperToList.add(paperTo);
            }
        } catch (SQLException e) {
            //运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        return paperToList;
    }

    /**
     * 条件统计
     * @param condition 条件
     * @return 试卷对象
     */
    @Override
    public int count(String condition) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回表中总数行数
        int rowCount=0;


        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写要执行的sql命令语句
            String sql="select  count(*) as pacount from Paper p  where 1=1"+condition;
            //使用数据库连接对象和sql字符串俩实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行slq命令，并返回影响行数
            rs=pstmt.executeQuery();
            //判断结果集，并获得总数
            if(rs.next()){
                //如果统计行数时没有指定别名，则用数字0作为参数
                rowCount=rs.getInt("pacount");
            }
        } catch (SQLException e) {
            //运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回表中的总行数
        return rowCount;
    }

    /**
     * 获取查询条件
     *
     * @param paper 试卷对象
     * @return
     */
    @Override
    public String getCondition(Paper paper) {
        //定义查询条件字语句，初值为带空格的字符串（注意后续条件中的空格）
        String condition=" ";
        //如果试卷对象为空，则直接返回空字符串
        if(paper==null){
            return condition;
        }
        //如果试卷编号不为空
        if(paper.getPaperId()!=0){
            condition +=" and p.paperId="+paper.getPaperId();
        }
        //如果班级编号不为0
        if(paper.getClassId()!=0){
            condition +=" and p.classId="+paper.getClassId();
        }
        //如果课程编号不为0
        if(paper.getCourseId()!=0){
            condition +=" and p.courseId="+paper.getCourseId();
        }
        //如果试题编号组不为空
        if(paper.getSubjectIds()!=null){
            condition +=" and p.subjectId="+paper.getSubjectIds();
        }
        //如果存在考试日期
        if(paper.getExamDate()!=null && paper.getExamDate().trim().length()!=0){
            condition +=" and p.examDate like '%"+paper.getExamDate()+"%' ";
        }
        //考试开始时间不为空
        if(paper.getBeginTime()!=null){
            condition +=" and p.beginTime="+paper.getBeginTime();
        }
        //考试结束时间
        if(paper.getFinishTime()!=null){
            condition +=" and p.finishTime="+paper.getFinishTime();
        }
        //返回条件字符串
        return condition;
    }

    /**
     * 通过班级名称查询班级编号
     *
     * @param className 班级名称
     * @return
     */
    @Override
    public int findClassId(String className) {
        //定义班级编号
        int classId;
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;


        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写要执行的SQL命令语句
            String sql="SELECT  classId FROM class where className=? ";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给SQL命令中的占位符赋值
            pstmt.setString(1,className);
            //返回结果集对象
            rs=pstmt.executeQuery();
            if (rs.next()){
                classId=rs.getInt("classId");
                //返回班级编号
                return classId;
            }

        } catch (SQLException e) {
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        return 0;
    }

    /**
     * 通过科目名称查询科目编号
     *
     * @param courseName 课程名称
     * @return
     */
    @Override
    public int findCourseId(String courseName) {
        //定义课程编号
        int courseId;
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //返回结果集对象
        ResultSet rs=null;

        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写要执行的SQL命令语句
            String sql="SELECT  courseId FROM course where courseName=? ";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给SQL命令中的占位符赋值
            pstmt.setString(1,courseName);
            //返回结果集
            rs=pstmt.executeQuery();
            if (rs.next()){
                courseId=rs.getInt("courseId");
                //返回课程编号
                return courseId;
            }

        } catch (SQLException e) {
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        return 0;
    }

    /**
     * 通过题目编号查询题目
     *
     * @param subjectIds 试题组编号
     * @return
     */
    @Override
    public Subjects findSubjectIds(String subjectIds) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的题库对象
        Subjects subjects=new Subjects();
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写要执行的SQL命令语句
            String sql="SELECT  subjectId,subjectType,stem,optionA,optionB,optionC,optionD,optionE,optionF,optionG,optionH,correct FROM subjects WHERE subjectId=?";
            //实例化数据库连接对象
            pstmt=conn.prepareStatement(sql);
            //给SQL命令中的占位符赋值
            pstmt.setString(1,subjectIds);
            //返回结果集
            rs=pstmt.executeQuery();
            if (rs.next()){
                subjects.setSubjectId(rs.getInt("subjectId"));
                subjects.setSubjectType(rs.getString("subjectType"));
                subjects.setStem(rs.getString("stem"));
                subjects.setOptionA(rs.getString("optionA"));
                subjects.setOptionB(rs.getString("optionB"));
                subjects.setOptionC(rs.getString("optionC"));
                subjects.setOptionD(rs.getString("optionD"));
                subjects.setOptionE(rs.getString("optionE"));
                subjects.setOptionF(rs.getString("optionF"));
                subjects.setOptionG(rs.getString("optionG"));
                subjects.setOptionH(rs.getString("optionH"));
                subjects.setCorrect(rs.getString("correct"));
                //返回题库对象
                return subjects;
            }
        } catch (SQLException e) {
            new RuntimeException(e.getMessage(),e);
        }finally{
            //释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回空值
        return null;
    }

    /**
     * 查询试卷编号的方法
     *
     * @return
     */
    @Override
    public int selectStudentStatu() {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //定义试卷编号为0
        int paperId=0;
        //声明结果集对象
        ResultSet rs=null;
        try {
            //实例化数据库连接对象
            conn=JdbcUtils.getConnection();
            //编写要执行的SQL命令语句
            String sql="SELECT MAX(paperId) paperId FROM paper";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //返回结果集
            rs=pstmt.executeQuery();
            if (rs.next()){
                paperId=rs.getInt("paperId");
                //返回试卷编号
                return paperId;
            }
        } catch (SQLException e) {
            new RuntimeException(e.getMessage(),e);
        }finally{
            //释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回0
        return 0;
    }

    /**
     * 添加学员状态
     *
     * @param paperId 试卷编号
     * @param s 学员对象
     * @param classId 班级编号
     */
    @Override
    public void addStuStatu(int paperId, Student s, int classId) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        try {
            //实例化数据库连接对象
            conn=JdbcUtils.getConnection();
            //编写要执行的SQL命令语句
            String sql="INSERT INTO statu(stuId,classId,paperId,conditions) VALUES(?,?,?,?)";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给SQL命令中的占位符赋值
            pstmt.setString(1,s.getStuId());
            pstmt.setInt(2,classId);
            pstmt.setInt(3,paperId);
            pstmt.setString(4,"待考试");
            pstmt.executeUpdate();
        } catch (SQLException e) {
            new RuntimeException(e.getMessage(),e);
        }finally{
            //释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
    }

    /**
     * 通过试卷编号查询试卷对应信息
     *
     * @param paperId 试卷编号
     * @return
     */
    @Override
    public Paper findPaperMsg(int paperId) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        try {
            //实例化预编译语句对象
            conn=JdbcUtils.getConnection();
            //编写要执行的SQL命令语句
            String sql="select * from paper where paperId=?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给SQL命令语句占位符赋值
            pstmt.setInt(1,paperId);
            //返回结果集对象
            rs=pstmt.executeQuery();
            if (rs.next()){
                //实例化试卷对象
                Paper paper=new Paper();
                paper.setPaperId(rs.getInt("paperId"));
                paper.setClassId(rs.getInt("classId"));
                paper.setCourseId(rs.getInt("courseId"));
                paper.setSubjectIds(rs.getString("subjectIds"));
                paper.setExamDate(rs.getString("examDate"));
                paper.setBeginTime(rs.getString("beginTime"));
                paper.setFinishTime(rs.getString("finishTime"));
                //返回试卷对象
                return paper;
            }
        } catch (SQLException e) {
            new RuntimeException(e.getMessage(),e);
        }finally{
            //释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回空值
        return null;
    }

    /**
     * 通过班级编号查询班级名称
     *
     * @param classId 班级编号
     * @return
     */
    @Override
    public String findClassName(int classId) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义班级名称
        String className;
        try {
            //实例化数据库连接对象
            conn=JdbcUtils.getConnection();
            //编写要执行的SQL命令语句
            String sql="select className from class where classId=?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给SQL命令的占位符赋值
            pstmt.setInt(1,classId);
            //返回结果集对象
            rs=pstmt.executeQuery();
            if (rs.next()){
                className=rs.getString("className");
                //返回班级名称
                return className;
            }
        } catch (SQLException e) {
            new RuntimeException(e.getMessage(),e);
        }finally{
            //释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回空值
        return null;
    }

    /**
     * 添加公告信息
     *
     * @param addNotice 添加公告
     */
    @Override
    public void addNoticeMsg(AddNotice addNotice) {
        Connection conn=null;
        PreparedStatement pstmt=null;
        ResultSet rs=null;
        try {
            conn=JdbcUtils.getConnection();
            String sql="INSERT INTO notice(teacherId,noticeBody,classId,noticeBeginTime,noticeOutTime) VALUES(?,?,?,?,?)";
            pstmt=conn.prepareStatement(sql);
            pstmt.setInt(1,addNotice.getTeacherId());
            pstmt.setString(2,addNotice.getNoticeBody());
            pstmt.setInt(3,addNotice.getClassId());
            pstmt.setString(4,addNotice.getNoticeBeginTime());
            pstmt.setString(5,addNotice.getNoticeOutTime());
            pstmt.executeUpdate();
        } catch (SQLException e) {
            new RuntimeException(e.getMessage(),e);
        }finally{
            JdbcUtils.close(rs,pstmt,conn);
        }
    }

    /**
     * 通过试卷编号删除考生状态对应信息
     */
    @Override
    public void deleteStatu(int paperId) {
        //定义一个执行后影响行数的变量
        int rows=0;
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;


        try {
            //使用jdbcutils工具类实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //定义sql命令字符串
            String sql="delete from statu where paperId=?";
            //使用数据库连接对象和sql字符串俩实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给sql命令中的占位符赋值
            pstmt.setInt(1, paperId);
            //使用预编译语句对象执行slq命令，并返回影响行数
            pstmt.executeUpdate();
        } catch (SQLException e) {
            //运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
    }
}
